home *** CD-ROM | disk | FTP | other *** search
/ Delphi Magazine Collection 2001 / Delphi Magazine Collection 20001 (2001).iso / DISKS / ISSUE08 / DATADICT / DDCOMP.PAS < prev    next >
Encoding:
Pascal/Delphi Source File  |  1995-11-08  |  36.3 KB  |  894 lines
  1. unit Ddcomp;
  2.  
  3. interface
  4. uses
  5.   SysUtils, Classes, Forms, Controls,
  6.   Dialogs, DB, DBTables, inifiles, grids;
  7. const
  8.     FieldTypeStr : array[ftunknown..ftgraphic] of string[8] =
  9.       ('Unknown', 'String', 'Smallint', 'Integer', 'Word',
  10.        'Boolean', 'Float', 'Currency', 'BCD', 'Date', 'Time',
  11.        'DateTime', 'Bytes', 'VarBytes', 'Blob', 'Memo', 'Graphic');
  12.     FieldTypeLtr : array[ftunknown..ftgraphic] of string[1] =
  13.       ('U', 'S', 'I', 'N', 'W',
  14.        'L', 'F', 'C', 'B', 'D', 'T',
  15.        'A', 'Y', 'V', 'O', 'M', 'G');
  16.  
  17. type
  18.   DDValidationtype = (IsValidDD, DoesNotExist, ExistbutnotDD, NewDD, EmptyString );
  19.  
  20.   TDDCtrl = class(TComponent)
  21.   private
  22.     DictDB: TDatabase;
  23.     DictTable: TTable;
  24.     DictQuery: TQuery;
  25.     DictSource: TDataSource;
  26.     FiniFile : TiniFile;
  27.     FCtrlDictName : Tfilename; {fully qualified name}
  28.     FDictStatus : DDValidationType;
  29.     FDBSGGood : boolean;
  30.     FTableList : tStrings;
  31.     FDBSG : Tstringgrid;  {active part of dictionary}
  32.     FUpdated : Tdatetime; {info on current dictionary}
  33.     FDictsize : longint;
  34.     FnumRecords,
  35.     Fnumtables,
  36.     FnumFields : integer;
  37.     procedure ReadIniFile;
  38.     function getDictPath : tfilename;
  39.     procedure setDictPath( tmpstr : tfilename);
  40.     function getDictTable : tfilename;
  41.     procedure setDictTable (tmpstr : tfilename);
  42.     function setUpCommon(var TableToDefine : ttable; const cur_row : integer): boolean;
  43.     function SetUpString(var TableToDefine : ttable; const cur_row : integer): boolean;
  44.     function SetUpBoolean(var TableToDefine : ttable; const cur_row : integer): boolean;
  45.     function doNumbers(const whichtype : char; var TableToDefine : ttable; const cur_row : integer): boolean;
  46.     function setAfterFieldDef(var tableToDefine : Ttable; const cur_row : integer): boolean;
  47.     function setUpBeforeCommon(var TableToDefine : ttable; const cur_row : integer): boolean;
  48.     function SetUpBeforeString(var TableToDefine : ttable; const cur_row : integer): boolean;
  49.     function SetUpBeforeBoolean(var TableToDefine : ttable; const cur_row : integer): boolean;
  50.     function doBeforeNumbers(const whichtype : char; var TableToDefine : ttable; const cur_row : integer): boolean;
  51.     function setBeforeFieldDef(var tableToDefine : Ttable; const cur_row : integer): boolean;
  52.  
  53.   protected
  54.     function OpenDD(const pathname, tablename : string): boolean;
  55.     function CheckOutDD(const Fulltablename : string): DDValidationtype;
  56.     function BuildDictCtrlGrid(SQLparams : string): boolean;
  57.     function ValidateDictCtrlGrid: boolean;
  58.     function tableInDBSG(const whichtable : string): boolean;
  59.   public
  60.     Constructor create(Aowner : Tcomponent); override;
  61.     function SetUpTableBeforeOpen(var TableToSetUp : ttable; const whichTable : string): boolean;
  62.     function SetUpTableAfterOpen(var TableToSetUp : ttable; const whichTable : string): boolean;
  63.  
  64.   published
  65.     property DictStatus: DDValidationType read FDictStatus;
  66.     property FullDDName : tFilename read FCtrlDictName write FCtrlDictName;
  67.     property DictPathName: Tfilename read getDictPath;
  68.     property DictTableName: Tfilename read getDictTable;
  69.     property LastUpdate: tDateTime read Fupdated;
  70.     property DictSize: longint read FDictSize;
  71.     property NumRecords: integer read FNumRecords;
  72.     property numtables: integer read fNumtables;
  73.     property numfields: integer read fNumFields;
  74.     property DBSGExists : boolean read FDBSGGood;
  75.   end;
  76.  
  77.  
  78. procedure Register;
  79.  
  80. var
  81.  
  82. DDctrlIsInit : boolean;
  83.  
  84.  
  85. implementation
  86.  
  87.  
  88. uses utils
  89. {$ifdef buggy}, runinfo {$endif};
  90. const
  91.    {indexes into DBSG columns}
  92.       ddTablename = 0;  {string 20}
  93.       ddTabletype = 1;  {string 20}
  94.       ddFieldname = 2;  {string[20];}
  95.       ddTagfld    = 3;  {string 20  tfield.tag}
  96.       ddScrprompt = 4;  {string[40]; {tfield.DisplayName}
  97.       ddScrformat = 5;  {string[80]; {tfield.DisplayText -- an editmask}
  98.       ddGrdprompt = 6;  {string[10];}
  99.       ddGrdwidth  = 7;  {smallint    {tfield.DisplayWidth}
  100.       ddFldtype   = 8;  {string[1];  {FieldTypeLtr}
  101.       ddFldlen    = 9;  {smallint    {tfield.size}
  102.       ddFlddec    = 10; {smallint}
  103.       ddFldidx    = 11; {boolean;}
  104.       ddIdxexp    = 12; {string;}
  105.       ddTab_order = 13; {integer;}
  106.       ddRequired  = 14; {boolean;    {tfield.required}
  107.       ddDefault   = 15; {string[80];}
  108.       ddEditmask  = 16; {string[80]; {tfield.editMask}
  109.       ddMinval    = 17; {ftfloat  tfield.minvalue}
  110.       ddMaxval    = 18; {ftfloat  tfield.maxvalue}
  111.       ddVallist   = 19; {ftmemo   list of valid strings}
  112.       { define      documentation only
  113.         validvalue  documentation only
  114.         notes       documentation only}
  115.       ddHintTxt   = 20;  {string 120}
  116.       ddHelpid    = 21;  {longint;}
  117.       {help, memo only used if helpid not null or 0}
  118.       ddHasLink   = 22;  {boolean;}
  119.       ddSrclinktbl = 23; {string[20];}
  120.       ddSrclinkfld = 24; {string[20];}
  121.       ddIsCalc     = 25; {boolean;}
  122.       ddFormula    = 26; {memo only used if iscalc true}
  123.  
  124. Procedure TDDCtrl.ReadIniFile;
  125. begin
  126.   FIniFile := TiniFile.Create(appname+'.ini');
  127.   FCtrlDictName := FiniFile.ReadString('CtrlDict', 'current', appname+'.dbf');
  128.   FiniFile.free;
  129. end;
  130.  
  131. function TDDCtrl.getDictPath : tfilename;
  132. begin
  133.   result := extractFilePath(FCtrlDictName);
  134. end;
  135. procedure TDDCtrl.setDictPath( tmpstr : tfilename);
  136. begin
  137.   FCtrlDictName := tmpstr;
  138. end;
  139. function TDDCtrl.getDictTable : tfilename;
  140. begin
  141.   result := copy(extractFileName(FCtrlDictName), 1, pos('.',extractFileName(FCtrlDictName))-1);
  142. end;
  143. procedure TDDCtrl.setDictTable (tmpstr : tfilename);
  144. begin
  145. end;
  146.  
  147. constructor TDDCtrl.create(Aowner : Tcomponent);
  148. begin
  149.   inherited create(Aowner);
  150.   {$ifdef buggy}
  151.     runinfoform.updateinfo( 'Start ddctrl');
  152.   {$endif}
  153.   readIniFile;
  154.   DictDB := Tdatabase.Create(Aowner);
  155.   DictTable := TTable.create(Aowner);
  156.   DictQuery := TQuery.create(Aowner);
  157.   DictSource := Tdatasource.create(aOwner);
  158.   DictDB.Databasename := 'DataDictCtrlFormDB';
  159.   if CheckOutDD(FCtrlDictName) = IsValidDD
  160.     then begin
  161.  
  162.       messagedlg('foundit', mtinformation, [mbOK],0);
  163.  
  164.       {first check it out}
  165.       {pull data into stringgrid?
  166.        or set up a permanent link/ query table
  167.        with data to modify current app
  168.        }
  169.       end
  170.     else begin
  171.       messagedlg('not IsValidDD', mtinformation, [mbOK],0);
  172.       {some kind of message about no dictionary
  173.        present?
  174.        }
  175.       end;
  176.    {$ifdef buggy}
  177.      runinfoform.updateinfo('before ddctrl done');
  178.    {$endif}
  179.    DictSource.free;
  180.    DictQuery.free;
  181.    DictTable.free;
  182.    DictDB.free;
  183.    {$ifdef buggy}
  184.    runinfoform.updateinfo('end create ddctrl');
  185.    {$endif}
  186. end;
  187.  
  188.  
  189. function TDDCtrl.openDD(const pathname, tablename : string): boolean;
  190. begin
  191.   try
  192.     DictDB.close;
  193.     DictDB.Params.clear;
  194.     DictDB.Params.Add('PATH='+PathName);
  195.     DictDB.DriverName := 'STANDARD';
  196.     DictDB.open;
  197.     DictTable.DatabaseName:= DictDB.databasename;
  198.     DictTable.TableType := ttDbase;
  199.     DictTable.tablename := TableName;
  200.     DictTable.Active:= True;
  201.     DictSource.DataSet:= DictTable;
  202.     DictQuery.databaseName := DictDB.databasename;
  203.     DictQuery.dataSource := DictSource;
  204.     DictQuery.close;
  205.     DictQuery.sql.clear;
  206.     DictQuery.params.clear;
  207.     result := true;
  208.   except
  209.      on EdataBaseError do begin
  210.        screen.cursor := crDefault;
  211.        MessageDlg('Could not open '+pathname + ' '+tablename, mtInformation, [mbOK], 0);
  212.        result := false;
  213.        end;
  214.      end; {of exceptions}
  215. end;
  216.  
  217. function TDDCtrl.CheckOutDD(const Fulltablename : string): DDValidationtype;
  218. var
  219.     tablefound : boolean;
  220.     sqlstr,
  221.     thistable : string;
  222.     tablenum : integer;
  223.     FileInfo : TsearchRec;
  224.     tableField : tField;
  225.  
  226. begin
  227.   result := isValidDD;
  228.   fnumtables := 0;  fnumFields := 0; fDictsize := 0; fNumRecords := 0;
  229.   FTableList := tstringlist.create;
  230.   if fileExists(fulltablename)
  231.     then begin
  232.       FindFirst(fulltablename, faAnyfile, fileinfo);
  233.       FUpdated := fileDateToDateTime(Fileinfo.time);
  234.       fDictSize := FileInfo.size;
  235.       {not total size, should also get size of .dbt }
  236.       end
  237.     else begin
  238.       result := DoesNotExist;
  239.       exit;
  240.       end;
  241.   if openDD(DictPathName, DictTableName)
  242.     then begin
  243.       fnumrecords := DictTable.RecordCount;
  244.       sqlstr := 'SELECT * FROM '+DictTableName;
  245.       Dictquery.sql.add(sqlstr);
  246.       Dictquery.prepare;
  247.       Dictquery.open;
  248.       Dictquery.first;
  249.       { get tablenames in data dictionary, stick in M_tableList lines}
  250.       if DictQuery.findfield('TABLE_NAME') = nil
  251.         then begin
  252.            result := ExistButNotDD;
  253.            exit;
  254.            end;
  255.       ftableList.add(DictQuery.findfield('TABLE_NAME').text);  {get first one}
  256.       inc(fnumfields);
  257.       DictQuery.next;
  258.       while not DictQuery.eof do begin
  259.         tablefound := false;
  260.         thistable := DictQuery.findfield('TABLE_NAME').text;
  261.         inc(fnumFields);
  262.         for tablenum := 0 to ftablelist.count - 1 do
  263.           if ftableList.strings[tablenum] = thistable
  264.              then begin
  265.                 tablefound := true;
  266.                 break;
  267.                 end;
  268.           {done looking for thistable}
  269.         if not tablefound
  270.           then  ftablelist.add(thistable);
  271.         DictQuery.next;
  272.         end; {while searching for table names}
  273.     DictQuery.close;
  274.     If not BuildDictCtrlGrid(sqlstr)
  275.       then result := ExistButNotDD;
  276.     end
  277.   else begin
  278.     result := ExistbutnotDD;
  279.     end;
  280. end;
  281.  
  282. function TDDCtrl.BuildDictCtrlGrid(sqlparams : string): boolean;
  283. var
  284.   tmpstr : string;
  285.   tablefound : boolean;
  286.   tablenum,
  287.   cur_row   : integer;
  288. begin
  289.   try
  290.    DictQuery.close;
  291.    DictQuery.sql.clear;
  292.    DictQuery.params.clear;
  293.    tmpstr := sqlparams +' where TABLE_NAME = :tableid';
  294.    DictQuery.sql.add(tmpstr);
  295.    DictQuery.prepare;
  296.    cur_row := 0;
  297.    fdbsg := TstringGrid.create(self);
  298.    fdbsg.rowcount := DictTable.recordCount;
  299.    fdbsg.colcount := DictTable.fieldCount;
  300.    for tablenum := 0 to FTableList.count - 1 do begin
  301.      DictQuery.close;
  302.      DictQuery.ParamByName('tableid').asString := FtableList.strings[tablenum];
  303.      DictQuery.open;
  304.      DictQuery.first;
  305.      while not DictQuery.eof do begin
  306.        fDBSG.cells[ddtablename,cur_row] := DictQuery.findfield('TABLE_NAME').text;
  307.        fDBSG.cells[ddtabletype,cur_row] := DictQuery.findfield('TABLE_tYPE').text;
  308.        fDBSG.cells[ddfieldname,cur_row] := DictQuery.findfield('FIELD_NAME').text;
  309.        fDBSG.cells[ddtagfld,cur_row] := DictQuery.findfield('TAG').text;
  310.        fDBSG.cells[ddscrprompt,cur_row] := DictQuery.findfield('SCR_PROMPT').text;
  311.        fDBSG.cells[ddscrformat,cur_row] := DictQuery.findfield('SCR_FMT').text;
  312.        fDBSG.cells[ddgrdprompt,cur_row] := DictQuery.findfield('GRD_PROMPT').text;
  313.        fDBSG.cells[ddgrdwidth,cur_row] := DictQuery.findfield('GRD_WIDTH').asString;
  314.        fDBSG.cells[ddfldtype  ,cur_row] := DictQuery.findfield('FIELD_TYPE').text;
  315.        fDBSG.cells[ddfldlen   ,cur_row] := DictQuery.findfield('FIELD_LEN').asString;
  316.        fDBSG.cells[ddflddec   ,cur_row] := DictQuery.findfield('FIELD_DEC').asString;
  317.        fDBSG.cells[ddfldidx   ,cur_row] := DictQuery.findfield('FIELD_IDX').asString;
  318.        fDBSG.cells[ddidxexp   ,cur_row] := DictQuery.findfield('IDX_EXPRES').text; {first line only}
  319.        fDBSG.cells[ddtab_order ,cur_row] := DictQuery.findfield('TAB_ORDER').asString;
  320.        fDBSG.cells[ddrequired ,cur_row] := DictQuery.findfield('REQUIRED').asString;
  321.        fDBSG.cells[dddefault  ,cur_row] := DictQuery.findfield('DEFAULT').text;
  322.        fDBSG.cells[ddeditmask ,cur_row] := DictQuery.findfield('EDITMASK').text;
  323.        fDBSG.cells[ddminval   ,cur_row] := DictQuery.findfield('MINVAL').asString;
  324.        fDBSG.cells[ddmaxval   ,cur_row] := DictQuery.findfield('MAXVAL').asString;
  325.        fDBSG.cells[ddvallist  ,cur_row] := DictQuery.findfield('VALLIST').text; {first line only}
  326.        fDBSG.cells[ddhinttxt  ,cur_row] := DictQuery.findfield('HINT').text;
  327.        fDBSG.cells[ddhelpid   ,cur_row] := DictQuery.findfield('HELPID').asSTring;
  328.        fDBSG.cells[ddhaslink  ,cur_row] := DictQuery.findfield('HASLINK').asSTring;
  329.        fDBSG.cells[ddsrclinktbl ,cur_row] := DictQuery.findfield('SRCLINKTBL').text;
  330.        fDBSG.cells[ddsrclinkfld ,cur_row] := DictQuery.findfield('SRCLINKFLD').text;
  331.        fDBSG.cells[ddiscalc   ,cur_row] := DictQuery.findfield('IS_CALC').asString;
  332.        fDBSG.cells[ddformula  ,cur_row] := DictQuery.findfield('FORMULA').text;
  333.        inc(cur_row);
  334.        DictQuery.next;
  335.        end;
  336.      end;
  337.    result := true;
  338.   except
  339.     on EdataBaseError do begin
  340.       screen.cursor := crDefault;
  341.       MessageDlg('Problem reading fields in from dictionary', mtInformation, [mbOK], 0);
  342.       result := False;
  343.       end;
  344.     end; {of exceptions}
  345.   if result
  346.     then FDBSGgood := validateDictCtrlGrid
  347.     else FDBSGgood := false;
  348. end;
  349.  
  350. function TDDctrl.ValidateDictCtrlGrid: boolean;
  351. var cur_row : integer;
  352.     thisFieldType : string[1];
  353.     found : boolean;
  354.     thisfield : ftString..ftGraphic;
  355.  
  356.   procedure nogood(const messg : string; const row_num : integer);
  357.   begin
  358.     messagedlg(messg+' at row '+intToStr(row_num), mtInformation, [mbOK], 0);
  359.     result := false;
  360.   end;
  361.  
  362. begin
  363. {  if Not FDBSGgood
  364.     then begin
  365.       Result := false;
  366.       MessageDlg('DB Control structure does not exist', mtinformation, [mbOK],0);
  367.       end
  368.     else begin with fDBSG do begin}
  369.   with fDBSG do begin
  370.       result := true;
  371.       for cur_row := 0 to rowcount -1 do begin
  372.          if fDBSG.cells[ddtablename,cur_row] = ''
  373.            then nogood('Blank Table name',cur_row);
  374.          if fDBSG.cells[ddfieldname,cur_row] = ''
  375.            then nogood('Field name blank',cur_row);
  376.          if fDBSG.cells[ddfldtype  ,cur_row] = ''
  377.            then nogood('Field type blank',cur_row)
  378.            else begin
  379.              found := false;
  380.              ThisFieldType := fDBSG.cells[ddfldtype, cur_row];
  381.              for thisfield := ftString to ftgraphic do
  382.                 if FieldTypeLtr[thisfield] = thisfieldtype
  383.                   then begin found := true; break; end;
  384.              if not found
  385.                then nogood('Invalid field type: '+ThisFieldType, cur_row);
  386.              end;
  387.          end; {for cur_row to rowcount}
  388.       end; {with fDBSG}
  389. end;
  390.  
  391. function TDDCtrl.tableInDBSG(const whichtable : string): boolean;
  392. var i : integer;
  393. begin
  394.   result := false;
  395.   with fTableList do
  396.     for i := 0 to Ftablelist.count -1 do
  397.       if whichtable = Ftablelist.strings[i]
  398.         then begin result := true; break; end;
  399. end;
  400.  
  401.  
  402.  
  403.  
  404.  
  405. function TDDctrl.SetUpCommon(var TableToDefine : ttable; const cur_row : integer): boolean;
  406. var whichfield : string;
  407. begin with fDBSG do begin
  408.   whichfield := cells[ddfieldname, cur_row];
  409.   if cells[ddtagfld, cur_row] <> ''
  410.     then TableToDefine.findField(whichField).tag := StrToint(cells[ddtagfld, cur_row]);
  411.   {if cells[ddscrprompt,cur_row] <> ''
  412.     then TableToDefine.findField(whichField). := cells[ddscrprompt, cur_row];}
  413.   if cells[ddgrdprompt,cur_row] <> ''
  414.     then TableToDefine.findfield(whichField).DisplayLabel := cells[ddgrdprompt, cur_row];
  415.   if cells[ddgrdwidth,cur_row] <> ''
  416.     then TableToDefine.findfield(whichField).DisplayWidth := StrToInt(cells[ddgrdwidth, cur_row]);
  417.   if cells[ddEditMask, cur_row] <> ''
  418.     then TableToDefine.findField(whichfield).EditMask
  419.             := cells[ddEditMask, cur_row];
  420.   if cells[ddrequired ,cur_row] = 'true'
  421.     then TableToDefine.findfield(whichfield).required := true
  422.     else TableToDefine.findField(whichField).required := false;
  423.    {
  424.             fDBSG.cells[dddefaultis  ,cur_row] := qry.findfield('DEFAULT').text;
  425.             fDBSG.cells[ddeditmaskis ,cur_row] := qry.findfield('EDITMASK').text;
  426.             fDBSG.cells[ddminval   ,cur_row] := qry.findfield('MINVAL').asString;
  427.             fDBSG.cells[ddmaxval   ,cur_row] := qry.findfield('MAXVAL').asString;
  428.             fDBSG.cells[ddvallist  ,cur_row] := qry.findfield('VALLIST').text;
  429.             fDBSG.cells[ddhinttxt  ,cur_row] := qry.findfield('HINT').text;
  430.             fDBSG.cells[ddhelpid   ,cur_row] := qry.findfield('HELPID').asSTring;
  431.             fDBSG.cells[ddhaslink  ,cur_row] := qry.findfield('HASLINK').asSTring;
  432.             fDBSG.cells[ddsrclinktbl ,cur_row] := qry.findfield('SRCLINKTBL').text;
  433.             fDBSG.cells[ddsrclinkfld ,cur_row] := qry.findfield('SRCLINKFLD').text;
  434.             fDBSG.cells[ddiscalc   ,cur_row] := qry.findfield('IS_CALC').asString;
  435.             fDBSG.cells[ddformula  ,cur_row] := qry.findfield('FORMULA').text;
  436.      tfield }
  437.  
  438.  
  439.   end;
  440. end;
  441.  
  442. function TDDCtrl.SetUpString(var TableToDefine : ttable; const cur_row : integer): boolean;
  443. var whichfield : string;
  444. begin with fDBSG do begin
  445.   whichfield := cells[ddfieldname, cur_row];
  446.   if cells[ddscrFormat,cur_row] <> ''
  447.     then TableToDefine.findField(whichfield).EditMask
  448.             := cells[ddscrFormat,cur_row];
  449.   if cells[ddEditMask, cur_row] <> ''
  450.     then TableToDefine.findField(whichfield).EditMask
  451.             := cells[ddEditMask, cur_row];
  452. (** apparently cannot change size
  453.   well, suppose that makes sense.  So field_len only to be
  454.   used for strings when creating tables, not after they are built
  455.  
  456.   if cells[ddfldlen, cur_row] <> ''
  457.     then begin
  458.      { TableToDefine.active := false;}
  459.       TableToDefine.findField(whichField).size := StrToint(cells[ddfldlen, cur_row]);
  460.       {tableToDefine.active := true;}
  461.       end;
  462.   **)
  463.   end;
  464. end;
  465.  
  466. function TDDCtrl.SetUpBoolean(var TableToDefine : ttable; const cur_row : integer): boolean;
  467. var whichfield : string;
  468. begin with fDBSG do begin
  469.   whichfield := cells[ddfieldname, cur_row];
  470.   if cells[ddValList, cur_row] <> ''
  471.     then TBooleanField(TableToDefine.findField(whichfield)).DisplayValues
  472.             := cells[ddValList, cur_row];
  473.   end;
  474. end;
  475.  
  476.     {required
  477.               fDBSG.cells[ddtablename,cur_row] := qry.findfield('TABLE_NAME').text;
  478.             fDBSG.cells[ddfieldname,cur_row] := qry.findfield('FIELD_NAME').text;
  479.             fDBSG.cells[ddtag,cur_row] := qry.findfield('TAG').text;
  480.             fDBSG.cells[ddscrprompt,cur_row] := qry.findfield('SCR_PROMPT').text;
  481.             fDBSG.cells[ddscrformat,cur_row] := qry.findfield('SCR_FMT').text;
  482.             fDBSG.cells[ddgrdprompt,cur_row] := qry.findfield('GRD_PROMPT').text;
  483.             fDBSG.cells[ddgrdwidth,cur_row] := qry.findfield('GRD_WIDTH').asString;
  484.             fDBSG.cells[ddfldtype  ,cur_row] := qry.findfield('FIELD_TYPE').text;
  485.             fDBSG.cells[ddfldlen   ,cur_row] := qry.findfield('FIELD_LEN').asString;
  486.             fDBSG.cells[ddflddec   ,cur_row] := qry.findfield('FIELD_DEC').asString;
  487.             fDBSG.cells[ddfldidx   ,cur_row] := qry.findfield('FIELD_IDX').asString;
  488.             fDBSG.cells[ddidxexp   ,cur_row] := qry.findfield('IDX_EXPRES').text;
  489.             fDBSG.cells[ddtab_order ,cur_row] := qry.findfield('TAB_ORDER').asString;
  490.             fDBSG.cells[ddisrequired ,cur_row] := qry.findfield('REQUIRED').asString;
  491.             fDBSG.cells[dddefaultis  ,cur_row] := qry.findfield('DEFAULT').text;
  492.             fDBSG.cells[ddeditmaskis ,cur_row] := qry.findfield('EDITMASK').text;
  493.             fDBSG.cells[ddminval   ,cur_row] := qry.findfield('MINVAL').asString;
  494.             fDBSG.cells[ddmaxval   ,cur_row] := qry.findfield('MAXVAL').asString;
  495.             fDBSG.cells[ddvallist  ,cur_row] := qry.findfield('VALLIST').text;
  496.             fDBSG.cells[ddhinttxt  ,cur_row] := qry.findfield('HINT').text;
  497.             fDBSG.cells[ddhelpid   ,cur_row] := qry.findfield('HELPID').asSTring;
  498.             fDBSG.cells[ddhaslink  ,cur_row] := qry.findfield('HASLINK').asSTring;
  499.             fDBSG.cells[ddsrclinktbl ,cur_row] := qry.findfield('SRCLINKTBL').text;
  500.             fDBSG.cells[ddsrclinkfld ,cur_row] := qry.findfield('SRCLINKFLD').text;
  501.             fDBSG.cells[ddiscalc   ,cur_row] := qry.findfield('IS_CALC').asString;
  502.             fDBSG.cells[ddformula  ,cur_row] := qry.findfield('FORMULA').text;
  503.       }
  504.  
  505.  
  506.  
  507.  
  508.  
  509. function SetUpDate(var TableToDefine : ttable; const cur_row : integer): boolean;
  510. begin
  511. end;
  512.  
  513. function SetUpDateTime(var TableToDefine : ttable; const cur_row : integer): boolean;
  514. begin
  515. end;
  516.  
  517. function SetUpTime(var TableToDefine : ttable; const cur_row : integer): boolean;
  518. begin
  519. end;
  520.  
  521. function SetUpBytes(var TableToDefine : ttable; const cur_row : integer): boolean;
  522. begin
  523. end;
  524.  
  525. function SetUpVarBytes(var TableToDefine : ttable; const cur_row : integer): boolean;
  526. begin
  527. end;
  528.  
  529. function SetUpBlob(var TableToDefine : ttable; const cur_row : integer): boolean;
  530. begin
  531. end;
  532.  
  533. function SetUpMemo(var TableToDefine : ttable; const cur_row : integer): boolean;
  534. begin
  535. end;
  536.  
  537. function SetUpGraphic(var TableToDefine : ttable; const cur_row : integer): boolean;
  538. begin
  539. end;
  540.  
  541. function TDDCtrl.doNumbers(const whichtype : char; var TableToDefine : ttable; const cur_row : integer): boolean;
  542. var whichfield : string;
  543. begin with fDBSG do begin
  544.   whichfield := cells[ddfieldname, cur_row];
  545.   if (cells[ddminval, cur_row] = '') and (cells[ddmaxval, cur_row] = '')
  546.     then begin
  547.       result := true;
  548.       exit;
  549.       end;
  550.   case whichtype of
  551.        'I': begin  {ftSmallint}
  552.               if cells[ddminval, cur_row] <> ''
  553.                 then TSmallIntField(TableToDefine.findField(whichField)).minvalue
  554.                         := StrToInt(cells[ddMinVal, cur_row]);
  555.               if cells[ddmaxval, cur_row] <> ''
  556.                 then TSmallIntField(TableToDefine.findField(whichField)).maxvalue
  557.                         := StrToInt(cells[ddMaxVal, cur_row]);
  558.               end;
  559.        'N': begin  {ftInteger}
  560.               if cells[ddminval, cur_row] <> ''
  561.                 then TIntegerField(TableToDefine.findField(whichField)).minvalue
  562.                         := StrToInt(cells[ddMinVal, cur_row]);
  563.               if cells[ddmaxval, cur_row] <> ''
  564.                 then TIntegerField(TableToDefine.findField(whichField)).maxvalue
  565.                         := StrToInt(cells[ddMaxVal, cur_row]);
  566.               end;
  567.  
  568.        'W' : begin {ftWord}
  569.               if cells[ddminval, cur_row] <> ''
  570.                 then TWordField(TableToDefine.findField(whichField)).minvalue
  571.                         := StrToInt(cells[ddMinVal, cur_row]);
  572.               if cells[ddmaxval, cur_row] <> ''
  573.                 then TWordField(TableToDefine.findField(whichField)).maxvalue
  574.                         := StrToInt(cells[ddMaxVal, cur_row]);
  575.               end;
  576.        'F' : begin {ftFloat}
  577.               if cells[ddminval, cur_row] <> ''
  578.                 then TFloatField(TableToDefine.findField(whichField)).minvalue
  579.                         := StrToInt(cells[ddMinVal, cur_row]);
  580.               if cells[ddmaxval, cur_row] <> ''
  581.                 then TFloatField(TableToDefine.findField(whichField)).maxvalue
  582.                         := StrToInt(cells[ddMaxVal, cur_row]);
  583.               if cells[ddfldlen, cur_row] <> ''
  584.                then TFloatField(TableToDefine.findField(whichfield)).Precision
  585.                        := StrToInt(cells[ddfldlen, cur_row]);
  586.                          end;
  587.        'C' : begin {ftCurrency}
  588.               if cells[ddminval, cur_row] <> ''
  589.                 then TCurrencyField(TableToDefine.findField(whichField)).minvalue
  590.                         := StrToInt(cells[ddMinVal, cur_row]);
  591.               if cells[ddmaxval, cur_row] <> ''
  592.                 then TCurrencyField(TableToDefine.findField(whichField)).maxvalue
  593.                         := StrToInt(cells[ddMaxVal, cur_row]);
  594.               if cells[ddfldlen, cur_row] <> ''
  595.                then TCurrencyField(TableToDefine.findField(whichfield)).Precision
  596.                        := StrToInt(cells[ddfldlen, cur_row]);
  597.              end;
  598.        'B' : begin {ftBCD}
  599.               if cells[ddminval, cur_row] <> ''
  600.                 then TBCDField(TableToDefine.findField(whichField)).minvalue
  601.                         := StrToInt(cells[ddMinVal, cur_row]);
  602.               if cells[ddmaxval, cur_row] <> ''
  603.                 then TBCDField(TableToDefine.findField(whichField)).maxvalue
  604.                         := StrToInt(cells[ddMaxVal, cur_row]);
  605.               if cells[ddfldlen, cur_row] <> ''
  606.                then TBCDField(TableToDefine.findField(whichfield)).Precision
  607.                        := StrToInt(cells[ddfldlen, cur_row]);
  608.              end;
  609.        end; {Case }
  610.      end;   {with fDBSG}
  611. end;
  612.  
  613.  
  614. function TDDCtrl.setAfterFieldDef(var tableToDefine : Ttable; const cur_row : integer): boolean;
  615. var temprslt : boolean;
  616. begin
  617.   result := false;
  618.   temprslt := SetUpCommon(tableToDefine, cur_row);
  619.   case fDBSG.cells[ddfldtype,cur_row][1] of
  620.      'S' : {ftString}   Result := SetUpString(tableToDefine, cur_row);
  621.      'I',  {ftSmallint}
  622.      'N',  {ftInteger}
  623.      'W' : {ftWord}     Result := DoNumbers(fDBSG.cells[ddfldtype, cur_row][1], tableToDefine, cur_row);
  624.      'L' : {ftBoolean}  Result := SeTUpBoolean(tableToDefine, cur_row);
  625.      'F',  {ftFloat}
  626.      'C',  {ftCurrency}
  627.      'B' : {ftBCD}      Result := DoNumbers(fDBSG.cells[ddfldtype, cur_row][1], tableToDefine, cur_row);
  628.      'D' : {ftDate}     Result := SetUpDate(tableToDefine, cur_row);
  629.      'T' : {ftTime}     Result := SetUpTime(tableToDefine, cur_row);
  630.      'A' : {ftDateTime} Result := SetUpDateTime(tableToDefine, cur_row);
  631.      'Y' : {ftBytes}    Result := SetUpBytes(tableToDefine, cur_row);
  632.      'V' : {ftVarBytes} Result := SetUpVarBytes(tableToDefine, cur_row);
  633.      'O' : {ftBlob}     Result := SetUpBlob(tableToDefine, cur_row);
  634.      'M' : {ftMemo}     Result := SetUpMemo(tableToDefine, cur_row);
  635.      'G' : {ftGraphic}  Result := SetUpGraphic(tableToDefine, cur_row);
  636.      end; {Case & for}
  637.   result := result and temprslt;
  638. end;
  639.  
  640.  
  641. function TDDCtrl.SetUpTableAfterOpen(var TableToSetUp : ttable; const whichTable : string): boolean;
  642. var grid_row,
  643.     num_ok,
  644.     num_bad   : integer;
  645.     foundit   : boolean;
  646. begin
  647.   result := false;
  648.   num_ok := 0;  num_bad := 0;
  649.   if not tableInDBSG(whichtable)
  650.     then exit;
  651.   with fDBSG do begin
  652.     for grid_row := 0 to rowCount -1 do
  653.       if cells[ddTablename, grid_row] = whichtable
  654.         then if setAfterFieldDef( TableToSetUp, grid_row)
  655.                then inc(num_ok)
  656.                else inc(num_bad);
  657.     if num_bad = 0
  658.       then result := true;
  659.  
  660.   (**
  661.     {Is table loaded?}
  662.     for tablenum := 0 to ColCount - 1 do
  663.       if cols[0].strings[tablenum] = whichTable
  664.         then begin foundit := true; start_row := tablenum; break; end;
  665.         {done looking for table name}
  666.     if not foundit
  667.       then exit {returns false}
  668.       else begin
  669.         for tablenum := start_row to ColCount - 1 do
  670.           if cols[0].strings[tablenum] <> whichTable
  671.             then begin end_row := tablenum; break; end;
  672.         end;
  673.     **)
  674.     end; {with fDBSG}
  675. end;
  676.  
  677. {============================== before open table set up field defs ================}
  678.  
  679. function TDDctrl.SetUpBeforeCommon(var TableToDefine : ttable; const cur_row : integer): boolean;
  680. var whichfield : string;
  681. begin with fDBSG do begin
  682.   whichfield := cells[ddfieldname, cur_row];
  683. (**
  684.   if cells[ddtagfld, cur_row] <> ''
  685.     then TableToDefine.findField(whichField).tag := StrToint(cells[ddtagfld, cur_row]);
  686.   {if cells[ddscrprompt,cur_row] <> ''
  687.     then TableToDefine.findField(whichField). := cells[ddscrprompt, cur_row];}
  688.   if cells[ddgrdprompt,cur_row] <> ''
  689.     then TableToDefine.findfield(whichField).DisplayLabel := cells[ddgrdprompt, cur_row];
  690.   if cells[ddgrdwidth,cur_row] <> ''
  691.     then TableToDefine.findfield(whichField).DisplayWidth := StrToInt(cells[ddgrdwidth, cur_row]);
  692.   if cells[ddEditMask, cur_row] <> ''
  693.     then TableToDefine.findField(whichfield).EditMask
  694.             := cells[ddEditMask, cur_row];
  695.   if cells[ddrequired ,cur_row] = 'true'
  696.     then TableToDefine.findfield(whichfield).required := true
  697.     else TableToDefine.findField(whichField).required := false;
  698.    {
  699.             fDBSG.cells[dddefaultis  ,cur_row] := qry.findfield('DEFAULT').text;
  700.             fDBSG.cells[ddeditmaskis ,cur_row] := qry.findfield('EDITMASK').text;
  701.             fDBSG.cells[ddminval   ,cur_row] := qry.findfield('MINVAL').asString;
  702.             fDBSG.cells[ddmaxval   ,cur_row] := qry.findfield('MAXVAL').asString;
  703.             fDBSG.cells[ddvallist  ,cur_row] := qry.findfield('VALLIST').text;
  704.             fDBSG.cells[ddhinttxt  ,cur_row] := qry.findfield('HINT').text;
  705.             fDBSG.cells[ddhelpid   ,cur_row] := qry.findfield('HELPID').asSTring;
  706.             fDBSG.cells[ddhaslink  ,cur_row] := qry.findfield('HASLINK').asSTring;
  707.             fDBSG.cells[ddsrclinktbl ,cur_row] := qry.findfield('SRCLINKTBL').text;
  708.             fDBSG.cells[ddsrclinkfld ,cur_row] := qry.findfield('SRCLINKFLD').text;
  709.             fDBSG.cells[ddiscalc   ,cur_row] := qry.findfield('IS_CALC').asString;
  710.             fDBSG.cells[ddformula  ,cur_row] := qry.findfield('FORMULA').text;
  711.      tfield }
  712.    **)
  713.  
  714.   end;
  715. end;
  716.  
  717. function TDDCtrl.SetUpBeforeString(var TableToDefine : ttable; const cur_row : integer): boolean;
  718. var whichfield : string;
  719. begin with fDBSG do begin
  720.   whichfield := cells[ddfieldname, cur_row];
  721. {  if cells[ddfldlen, cur_row] <> ''
  722.     then TableToDefine.findField(whichField).size := StrToint(cells[ddfldlen, cur_row]);
  723.  }
  724.   end;
  725. end;
  726.  
  727. function TDDCtrl.SetUpBeforeBoolean(var TableToDefine : ttable; const cur_row : integer): boolean;
  728. var whichfield : string;
  729. begin with fDBSG do begin
  730.   whichfield := cells[ddfieldname, cur_row];
  731. {  if cells[ddValList, cur_row] <> ''
  732.     then TBooleanField(TableToDefine.findField(whichfield)).DisplayValues
  733.             := cells[ddValList, cur_row];
  734. }
  735.   end;
  736. end;
  737.  
  738. function TDDCtrl.dobeforeNumbers(const whichtype : char; var TableToDefine : ttable; const cur_row : integer): boolean;
  739. var whichfield : string;
  740. begin with fDBSG do begin
  741.   whichfield := cells[ddfieldname, cur_row];
  742.   if (cells[ddminval, cur_row] = '') and (cells[ddmaxval, cur_row] = '')
  743.     then begin
  744.       result := true;
  745.       exit;
  746.       end;
  747. (**
  748.   case whichtype of
  749.        'I': begin  {ftSmallint}
  750.               if cells[ddminval, cur_row] <> ''
  751.                 then TSmallIntField(TableToDefine.findField(whichField)).minvalue
  752.                         := StrToInt(cells[ddMinVal, cur_row]);
  753.               if cells[ddmaxval, cur_row] <> ''
  754.                 then TSmallIntField(TableToDefine.findField(whichField)).maxvalue
  755.                         := StrToInt(cells[ddMaxVal, cur_row]);
  756.               end;
  757.        'N': begin  {ftInteger}
  758.               if cells[ddminval, cur_row] <> ''
  759.                 then TIntegerField(TableToDefine.findField(whichField)).minvalue
  760.                         := StrToInt(cells[ddMinVal, cur_row]);
  761.               if cells[ddmaxval, cur_row] <> ''
  762.                 then TIntegerField(TableToDefine.findField(whichField)).maxvalue
  763.                         := StrToInt(cells[ddMaxVal, cur_row]);
  764.               end;
  765.  
  766.        'W' : begin {ftWord}
  767.               if cells[ddminval, cur_row] <> ''
  768.                 then TWordField(TableToDefine.findField(whichField)).minvalue
  769.                         := StrToInt(cells[ddMinVal, cur_row]);
  770.               if cells[ddmaxval, cur_row] <> ''
  771.                 then TWordField(TableToDefine.findField(whichField)).maxvalue
  772.                         := StrToInt(cells[ddMaxVal, cur_row]);
  773.               end;
  774.        'F' : begin {ftFloat}
  775.               if cells[ddminval, cur_row] <> ''
  776.                 then TFloatField(TableToDefine.findField(whichField)).minvalue
  777.                         := StrToInt(cells[ddMinVal, cur_row]);
  778.               if cells[ddmaxval, cur_row] <> ''
  779.                 then TFloatField(TableToDefine.findField(whichField)).maxvalue
  780.                         := StrToInt(cells[ddMaxVal, cur_row]);
  781.               if cells[ddfldlen, cur_row] <> ''
  782.                then TFloatField(TableToDefine.findField(whichfield)).Precision
  783.                        := StrToInt(cells[ddfldlen, cur_row]);
  784.                          end;
  785.        'C' : begin {ftCurrency}
  786.               if cells[ddminval, cur_row] <> ''
  787.                 then TCurrencyField(TableToDefine.findField(whichField)).minvalue
  788.                         := StrToInt(cells[ddMinVal, cur_row]);
  789.               if cells[ddmaxval, cur_row] <> ''
  790.                 then TCurrencyField(TableToDefine.findField(whichField)).maxvalue
  791.                         := StrToInt(cells[ddMaxVal, cur_row]);
  792.               if cells[ddfldlen, cur_row] <> ''
  793.                then TCurrencyField(TableToDefine.findField(whichfield)).Precision
  794.                        := StrToInt(cells[ddfldlen, cur_row]);
  795.              end;
  796.        'B' : begin {ftBCD}
  797.               if cells[ddminval, cur_row] <> ''
  798.                 then TBCDField(TableToDefine.findField(whichField)).minvalue
  799.                         := StrToInt(cells[ddMinVal, cur_row]);
  800.               if cells[ddmaxval, cur_row] <> ''
  801.                 then TBCDField(TableToDefine.findField(whichField)).maxvalue
  802.                         := StrToInt(cells[ddMaxVal, cur_row]);
  803.               if cells[ddfldlen, cur_row] <> ''
  804.                then TBCDField(TableToDefine.findField(whichfield)).Precision
  805.                        := StrToInt(cells[ddfldlen, cur_row]);
  806.              end;
  807.        end; {Case }
  808.   **)
  809.      end;   {with fDBSG}
  810. end;
  811.  
  812. function TDDCtrl.setBeforeFieldDef(var tableToDefine : Ttable; const cur_row : integer): boolean;
  813. var temprslt : boolean;
  814. begin
  815.   result := false;
  816.   temprslt := SetUpbeforeCommon(tableToDefine, cur_row);
  817.   case fDBSG.cells[ddfldtype,cur_row][1] of
  818.      'S' : {ftString}   Result := SetUpbeforeString(tableToDefine, cur_row);
  819.      'I',  {ftSmallint}
  820.      'N',  {ftInteger}
  821.      'W' : {ftWord}     Result := DoBeforeNumbers(fDBSG.cells[ddfldtype, cur_row][1], tableToDefine, cur_row);
  822.      'L' : {ftBoolean}  Result := SetUpBeforeBoolean(tableToDefine, cur_row);
  823.      'F',  {ftFloat}
  824.      'C',  {ftCurrency}
  825.      'B' : {ftBCD}      Result := DoBeforeNumbers(fDBSG.cells[ddfldtype, cur_row][1], tableToDefine, cur_row);
  826.      'D' : {ftDate}     Result := SetUpDate(tableToDefine, cur_row);
  827.      'T' : {ftTime}     Result := SetUpTime(tableToDefine, cur_row);
  828.      'A' : {ftDateTime} Result := SetUpDateTime(tableToDefine, cur_row);
  829.      'Y' : {ftBytes}    Result := SetUpBytes(tableToDefine, cur_row);
  830.      'V' : {ftVarBytes} Result := SetUpVarBytes(tableToDefine, cur_row);
  831.      'O' : {ftBlob}     Result := SetUpBlob(tableToDefine, cur_row);
  832.      'M' : {ftMemo}     Result := SetUpMemo(tableToDefine, cur_row);
  833.      'G' : {ftGraphic}  Result := SetUpGraphic(tableToDefine, cur_row);
  834.      end; {Case & for}
  835.   result := result and temprslt;
  836. end;
  837.  
  838.  
  839. function TDDCtrl.SetUpTableBeforeOpen(var TableToSetUp : ttable; const whichTable : string): boolean;
  840. var grid_row,
  841.     num_ok,
  842.     num_bad   : integer;
  843.     foundit   : boolean;
  844. begin
  845.   result := false;
  846.   num_ok := 0;  num_bad := 0;
  847.   if not tableInDBSG(whichtable)
  848.     then exit;
  849.   with fDBSG do begin
  850.     for grid_row := 0 to rowCount -1 do
  851.       if cells[ddTablename, grid_row] = whichtable
  852.         then if setBeforeFieldDef( TableToSetUp, grid_row)
  853.                then inc(num_ok)
  854.                else inc(num_bad);
  855.     if num_bad = 0
  856.       then result := true;
  857.     end; {with fDBSG}
  858. end;
  859.  
  860.  
  861.    {
  862.            TIntegerField       Whole numbers in the range -2,147,483,648 to 2,147,483,647
  863.             TWordField  Whole numbers in the range 0 to 65535
  864.             TBooleanField       True or False values
  865.             TFloatField Real numbers with absolute magnitudes from 5.0*10-324 to 1.7*10308
  866.                             accurate to 15-16 digits
  867.             TCurrencyField      Currency values. The range and accuracy is the same as TFloatField
  868.             TBCDField   Real numbers with a fixed number of digits after the decimal point.
  869.                             Accurate to 18 digits. Range depends on the number of digits after the
  870.                              decimal point. [Paradox only]
  871.             TDateField  Date value
  872.             TTimeField  Time value
  873.             TDateTimeField      Date and time value
  874.             TBytesField Arbitrary data field without a size limit
  875.             TVarBytesField      Arbitrary data field up to 65535 characters, with the actual length stored
  876.                             in the first two bytes
  877.             TBlobField  Arbitrary data field without a size limit
  878.             TMemoField  Arbitrary length text
  879.             TGraphicField       Arbitrary length graphic, such as a bitmap
  880.              }
  881.  
  882.  
  883. procedure Register;
  884. begin
  885.   RegisterComponents('Synature', [TDDCtrl]);
  886. end;
  887.  
  888. Initialization
  889.  
  890. DDctrlIsInit := false;
  891.  
  892. end.
  893.  
  894.